syopsyst.h

Go to the documentation of this file.

/*********************************************************************
 *
 *           Copyright (c) 2021 by Visuality Systems, Ltd.
 *
 *********************************************************************
 * FILE NAME     : $Workfile:$
 * ID            : $Header:$
 * REVISION      : $Revision:$
 *--------------------------------------------------------------------
 * DESCRIPTION   : OS-dependent definitions
 *                 This file is expected to be modified during porting
 *--------------------------------------------------------------------
 * MODULE        : Linux - SY
 * DEPENDENCIES  :
 ********************************************************************/

#ifndef _SYOPSYST_H_
#define _SYOPSYST_H_

#include "sycommon.h"
#ifdef UD_NQ_CODEPAGEUTF8
#include <iconv.h>
#endif /* UD_NQ_CODEPAGEUTF8 */ 

#define MUTEX_DEBUG     
#undef MUTEX_DEBUG

/* OS Name */

#define SY_OSNAME       "RedHat Linux"                   
#define syAssert(_stat_)        assert(_stat_)          
#define syGetTimeInSec()     time(0)         
NQ_TIME syGetTimeInMsec(void);

NQ_TIME syConvertTimeSpecToTimeInMsec(void * val);

NQ_UINT32
syConvertTimeInMsecToSec(
    NQ_TIME * timeMsec
    );

NQ_INT
syGetTimeZone(
    void
    );

void
syDecomposeTime(
    NQ_UINT32 time,
    SYTimeFragments* decomposed
    );

NQ_UINT32
syComposeTime(
    const SYTimeFragments* decomposed
    );


#define sySleep(_secs_) sleep(_secs_) 
#define syUSleep(_msecs_) usleep(_msecs_) 
#if defined(CM_NQ_STORAGE) || defined(DOXYGEN)

NQ_BOOL syGmtToString(NQ_BYTE * strTime, NQ_COUNT size, NQ_UINT32 t, const NQ_CHAR * fmt);
#endif

#define SYThread                    pthread_t               
#define syIsValidThread(_taskId_)   TRUE

#define syThreadGetCurrent          pthread_self

void syThreadStart(NQ_BOOL isRT, NQ_INT priorityLevel, SYThread *taskIdPtr, void (*startpoint)(void), NQ_BOOL background);

#define syThreadDestroy(_taskId_)   pthread_cancel(_taskId_);

/* mutex */

#ifndef MUTEX_DEBUG
#define SYMutex                       pthread_mutex_t
#else
typedef struct SYMutex
{
    pthread_mutex_t mutex;
    int lockCounter;
    char who[3][120];
    NQ_UINT where[3];
}_SYMutex;
#endif

void syMutexCreate(SYMutex* _m);

#if defined(MUTEX_DEBUG) || defined(DOXYGEN)

/* Mutex functions - add prints per mutex create, take, give, destroy */
void syMutexDelete(SYMutex* _m);

void syMutexTakeDebug(SYMutex *_m, const NQ_CHAR *text, const NQ_UINT line);
#define syMutexTake(_m) syMutexTakeDebug(_m, SY_LOG_FILE, SY_LOG_LINE)

void syMutexGive(SYMutex* _m);

#else
/* regular mutex operations */
#define syMutexDelete(_m)             pthread_mutex_destroy(_m)
#define syMutexTake(_m)               pthread_mutex_lock(_m)
#define syMutexGive(_m)               pthread_mutex_unlock(_m)
#endif

#define SY_SEMAPHORE_AVAILABLE 
#if defined(SY_SEMAPHORE_AVAILABLE) || defined(DOXYGEN)

#define SYSemaphore                   sem_t 
NQ_STATUS
sySemaphoreCreate(
    SYSemaphore* semId,
    NQ_UINT count
    );

void
sySemaphoreResetCounter(
    SYSemaphore* pSemID
    );

#define sySemaphoreDelete(_s)         sem_destroy(&_s)
#define sySemaphoreTake(_s)           sem_wait(&_s)
#define sySemaphoreGive(_s)           sem_post(&_s)

NQ_INT  sySemaphoreTimedTake( SYSemaphore *sem , NQ_INT timeout);

#endif /* SY_SEMAPHORE_AVAILABLE */

#if defined(UD_NQ_USETRANSPORTIPV6) || defined(DOXYGEN)

#ifdef SY_LITTLEENDIANHOST
#define SY_LOCALHOSTIP4 /*{0, 0} */  {0x007f, 0x0100}
#define SY_LOCALHOSTIP6 {0, 0, 0, 0, 0, 0, 0, 0x0100} /* {0, 0, 0, 0, 0, 0, 0, 0} */
#define SY_LINKLOCALIP  0x80fe
#else /* SY_LITTLEENDIANHOST */
#define SY_LOCALHOSTIP4 /*{0, 0} */ {0x7f00 , 0x0001}
#define SY_LOCALHOSTIP6 {0, 0, 0, 0, 0, 0, 0, 1} /* {0, 0, 0, 0, 0, 0, 0, 0} */
#define SY_LINKLOCALIP  0xfe80
#endif /* SY_LITTLEENDIANHOST */
#define SY_ANYIP4       {0, 0}
#define SY_ANYIP6       {0, 0, 0, 0, 0, 0, 0, 0}
#define SY_ZEROIP       {0, 0, 0, 0, 0, 0, 0, 0}

#else /* UD_NQ_USETRANSPORTIPV6 */

#ifdef SY_LITTLEENDIANHOST
#define SY_LOCALHOSTIP     0x0100007f
#else /* SY_LITTLEENDIANHOST */
#define SY_LOCALHOSTIP     0x7f000001
#endif /* SY_LITTLEENDIANHOST */
#define SY_ANYIP        0L
#define SY_ZEROIP       0L

#endif /* UD_NQ_USETRANSPORTIPV6 */

#define SY_ZEROIP4      0L

#if defined(UD_NQ_USETRANSPORTIPV6) || defined(DOXYGEN)

NQ_UINT32
syGetIPv6ScopeId(
    const NQ_IPADDRESS6 ip
    );
#endif /* UD_NQ_USETRANSPORTIPV6 */

#define SY_INTERNALSOCKETPOOL       
#undef SY_INTERNALSOCKETPOOL

#define SYSocketHandle              NQ_INT
#define SYSocketSet                 fd_set
#define syIsValidSocket(_sock)      (_sock != ERROR)

NQ_BOOL
syIsSocketAlive(
    SYSocketHandle sock
    );

#define syInvalidSocket()                   (ERROR)
#define syAddSocketToSet(_sock, _set)       FD_SET((_sock), (_set))
#define syIsSocketSet(_sock, _set)          FD_ISSET((_sock), (_set))
#define syClearSocketSet(_set)              FD_ZERO((_set))

#define syClearSocketFromSet(_sock, _set)   FD_CLR((_sock), (_set))

NQ_STATUS
syShutdownSocket(
    SYSocketHandle sock
    );
NQ_STATUS
syCloseSocket(
    SYSocketHandle sock
    );

NQ_STATUS
syListenSocket(
    SYSocketHandle sock,
    NQ_INT backlog
    );

SYSocketHandle
syCreateSocket(
    NQ_BOOL stream,
    NQ_UINT family
    );

NQ_STATUS
syBindSocket(
    SYSocketHandle sock,
    const NQ_IPADDRESS *ip,
    NQ_PORT port,
    NQ_BOOL reuseAddress
    );

NQ_STATUS
syAllowBroadcastsSocket(
    SYSocketHandle sock
    );

void
sySetClientSocketOptions(
    SYSocketHandle sock
    );

void
syGetSocketPortAndIP(
    SYSocketHandle sock,
    NQ_IPADDRESS *ip,
    NQ_PORT *port
    );

NQ_INT
sySendToSocket(
    SYSocketHandle sock,
    const NQ_BYTE* buf,
    NQ_COUNT len,
    const NQ_IPADDRESS *ip,
    NQ_PORT port
    );

NQ_STATUS
syConnectSocket(
    SYSocketHandle sock,
    const NQ_IPADDRESS *ip,
    NQ_PORT port
    );

NQ_INT
sySendSocket(
    SYSocketHandle sock,
    const NQ_BYTE* buf,
    NQ_COUNT len
    );

NQ_STATUS
sySendSocketAsync(
    SYSocketHandle sock,
    const NQ_BYTE* buf,
    NQ_COUNT len,
    void (*releaseFunc)(const NQ_BYTE*)
    );

NQ_INT
sySelectSocket(
    SYSocketSet* pset,
    NQ_UINT32 timeout
    );

NQ_INT
syRecvFromSocket(
    SYSocketHandle sock,
    NQ_BYTE* buf,
    NQ_COUNT len,
    NQ_IPADDRESS* ip,
    NQ_PORT* port
    );

NQ_INT
syRecvSocket(
    SYSocketHandle sock,
    NQ_BYTE* buf,
    NQ_COUNT len
    );

NQ_INT syRecvSocketWithTimeout(SYSocketHandle sock, NQ_BYTE * buf, unsigned int len,  unsigned int secs);

SYSocketHandle
syAcceptSocket(
    SYSocketHandle sock,
    NQ_IPADDRESS* ip,
    NQ_PORT* port
    );

#define sySetDatagramSocketOptions(_sock)
#define sySetStreamSocketOptions(_sock)

NQ_STATUS sySendMulticast(
    SYSocketHandle socket,
    const NQ_BYTE * buffer,
    NQ_COUNT length,
    const NQ_IPADDRESS *ip,
    NQ_PORT port);

void sySubscribeToMulticast(SYSocketHandle socket,
        const NQ_IPADDRESS *ip
        );

#define syGetPid()  getpid()

 /*
    Directories
    -----------

 */

#define SYDirectory                     DIR*
#define syInvalidateDirectory(_pd)      *(_pd) = NULL
#define syIsValidDirectory(_d)          (_d != NULL)

NQ_STATUS
syCreateDirectory(
    const NQ_WCHAR* name
    );

NQ_STATUS
syDeleteDirectory(
    const NQ_WCHAR* name
    );

SYDirectory
syOpenDirectory(
    const NQ_WCHAR* name
    );

NQ_STATUS
syFirstDirectoryFile(
    const NQ_WCHAR* name,
    SYDirectory* pDir,
    const NQ_WCHAR** fileName
    );

NQ_STATUS
syNextDirectoryFile(
    SYDirectory dir,
    const NQ_WCHAR** fileName
    );

NQ_STATUS
syCloseDirectory(
    SYDirectory dir
    );

/*
    Files
    -----

 */

#define SY_EXTENDFILENOTSUPPORTED 
#undef SY_EXTENDFILENOTSUPPORTED

#define SY_PATHSEPARATOR    '/'         
#define SYFile                          int             
#define syInvalidateFile(_f)            *_f = ERROR     
#define syIsValidFile(_file)            (_file!=ERROR)  
#define syInvalidFile()                 (ERROR)


#define SY_CP_FIRSTILLEGALCHAR          {0xe5} 
#define SY_CP_ANYILLEGALCHAR            {0x7c, 0x5c} 
SYFile
syCreateFile(
    const NQ_WCHAR* name,
    NQ_BOOL denyread,
    NQ_BOOL denyexecute,
    NQ_BOOL denywrite
    );

NQ_STATUS
syDeleteFile(
    const NQ_WCHAR* name
    );

NQ_STATUS
syRenameFile(
    const NQ_WCHAR* oldName,
    const NQ_WCHAR* newName
    );

SYFile
syOpenFileForRead(
    const NQ_WCHAR* name,
    NQ_BOOL denyread,
    NQ_BOOL denyexecute,
    NQ_BOOL denywrite
    );

SYFile
syOpenFileForWrite(
    const NQ_WCHAR* name,
    NQ_BOOL denyread,
    NQ_BOOL denyexecute,
    NQ_BOOL denywrite
    );

SYFile
syOpenFileForReadWrite(
    const NQ_WCHAR* name,
    NQ_BOOL denyread,
    NQ_BOOL denyexecute,
    NQ_BOOL denywrite
    );

NQ_STATUS
syTruncateFile(
    SYFile file,
    NQ_UINT32 offLow,
    NQ_UINT32 offHigh
    );

#define syFlushFile(_file)                         ((fsync(_file)==OK)? NQ_SUCCESS:NQ_FAIL)

NQ_INT
syReadFile(
    SYFile file,
    NQ_BYTE* buf,
    NQ_COUNT len
    );

NQ_INT
syWriteFile(
    SYFile file,
    const NQ_BYTE* buf,
    NQ_COUNT len
    );

NQ_STATUS
syCloseFile(
    SYFile fd
    );

NQ_UINT32
sySeekFileCurrent(
    SYFile file,
    NQ_INT32 off,
    NQ_INT32 offHigh
    );

NQ_UINT32
sySeekFileStart(
    SYFile file,
    NQ_UINT32 off,
    NQ_UINT32 offHigh
    );

NQ_UINT32
sySeekFileEnd(
    SYFile file,
    NQ_INT32 off,
    NQ_INT32 offHigh
    );

NQ_STATUS
syGetFileInformation(
    SYFile file,
    const NQ_WCHAR* fileName,
    SYFileInformation* fileInfo
    );

NQ_STATUS
syGetFileInformationByName(
    const NQ_WCHAR* fileName,
    SYFileInformation* fileInfo
    );

NQ_STATUS
syGetFileSize(
        SYFile file,
        NQ_UINT64 *size
        );

NQ_STATUS
sySetFileInformation(
    const NQ_WCHAR* fileName,
    SYFile handle,
    const SYFileInformation* fileInfo
    );

NQ_STATUS
syGetVolumeInformation(
    const NQ_WCHAR* name,
    SYVolumeInformation *info
    );

#define syGetSecurityDescriptor(_f, _i, _b)     udGetSecurityDescriptor(_f, _i, _b) 
#define sySetSecurityDescriptor(_f, _i, _b, _l) udSetSecurityDescriptor(_f, _i, _b, _l) 
#define syPrintf        printf
#define syFprintf       fprintf
#define sySprintf       sprintf
#define sySnprintf      snprintf
#define syVsnprintf     vsnprintf
#define sySscanf        sscanf
#define syScanf         scanf
#define syGetchar       getchar
#define syFflush        fflush

#define syUnlockFile(       \
            _file,          \
            _offsetHigh,    \
            _offsetLow,     \
            _lengthHigh,    \
            _lengthLow,     \
            _timeout        \
            )           ((_file==ERROR)? NQ_FAIL:NQ_SUCCESS)
#define syLockFile(         \
            _file,          \
            _offsetHigh,    \
            _offsetLow,     \
            _lengthHigh,    \
            _lengthLow,     \
            _lockType,      \
            _oplockLevel    \
            )           ((_file==ERROR)? NQ_FAIL:NQ_SUCCESS)

/*              
    Networking
    ----------

 */

#define   syGetHostName(_name, _nameLen)       gethostname((_name), (_nameLen))

NQ_IPADDRESS4
syGetHostByName(
    const char* name
    );

#if defined(UD_NQ_USETRANSPORTIPV4) || defined(UD_NQ_USETRANSPORTIPV6) || defined(DOXYGEN)

void
syGetDnsParams(
    NQ_CHAR *domain,
    NQ_IPADDRESS *server
    );
#endif /* defined(UD_NQ_USETRANSPORTIPV4) || defined(UD_NQ_USETRANSPORTIPV6) */

void
syGetMacAddress(
    NQ_IPADDRESS4 ip,
    NQ_BYTE* macBuffer
    );

NQ_STATUS
syGetAdapter(
    NQ_INDEX adapterIdx,
    NQ_INDEX * osIndex,
    NQ_IPADDRESS4* pIp,
    NQ_IPADDRESS6 *ip6,
    NQ_IPADDRESS4* pSubnet,
    NQ_IPADDRESS4* pBcast,
    NQ_WCHAR* pWins,
    NQ_WCHAR* pDns
    );

#if defined(UD_CS_INCLUDEDIRECTTRANSFER) || defined(DOXYGEN)

/*
    Socket-to-file-to-socket data transfer
    --------------------------------------

 */


NQ_STATUS
syDtStartPacket(
        SYSocketHandle sock
        );

void
syDtEndPacket(
        SYSocketHandle sock /* socket handle */
        );

NQ_STATUS
syDtFromSocket(
        SYSocketHandle sock,
        SYFile file,
        NQ_COUNT * len
        );

NQ_STATUS
syDtToSocket(
        SYSocketHandle sock,
        SYFile file,
        NQ_COUNT * len
        );

#endif /* UD_CS_INCLUDEDIRECTTRANSFER */

#define SY_UNICODEFILESYSTEM        
#undef  SY_UNICODEFILESYSTEM

#if defined(UD_CC_INCLUDELDAP) || defined(UD_NQ_CODEPAGEUTF8) || defined(DOXYGEN)

void
syUnicodeToUTF8N(
    NQ_CHAR *outStr,
    NQ_UINT outLength,
    const NQ_WCHAR *inWStr,
    NQ_UINT inLength
    );


void
syUTF8ToUnicodeN(
    NQ_WCHAR *outWStr,
    NQ_UINT outLength,
    const NQ_CHAR *inStr,
    NQ_UINT inLength
    );

#endif /* defined(UD_CC_INCLUDELDAP) || defined(UD_NQ_CODEPAGEUTF8) */

/*
    Using OS library for UTF 8
    --------------------------
*/
#if defined(UD_NQ_CODEPAGEUTF8) || defined(DOXYGEN)

NQ_BOOL initCodePageUTF8(void);
                
#endif /* UD_NQ_CODEPAGEUTF8 */

#define sySetRand()     srand((unsigned int)time(0))  
#define syRand()        rand()          
int
syUnixMode2DosAttr(
    int mode
    );

NQ_UINT32
syGetLastSmbError(
    void
    );

void
sySetLastNqError(
    NQ_STATUS nqErr
    );

#endif  /* _SYOPSYST_H_ */